home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #2 / Monster Media No. 2 (Monster Media)(1994).ISO / prog_c / ems4c.zip / EMM4C.C < prev    next >
Text File  |  1993-07-27  |  16KB  |  855 lines
  1. /*
  2. **  EMM4C.C  (Expanded Memory Manager for C)
  3. **
  4. **   --- please read this ! ---
  5. **
  6. **  This source code is in "shrouded" form. It is distributed in this form
  7. **  rather than as a library (.LIB) file because of the inconsistancies
  8. **  between object files generated by different compilers. To support several
  9. **  compilers would require a .LIB file for each compiler manufacturer, and
  10. **  sometimes several versions of the .LIB file are needed for the different
  11. **  versions of the same manufacturers compiler! This problem doesn't occur
  12. **  with assembler libraries, which is why EMS4C.LIB can be used with all C
  13. **  compilers.
  14. **
  15. **  You can compile this code, but you will have to register with us in order
  16. **  to get the normal (commented) C source code with normal variable names.
  17. */
  18.  
  19. #include <stdio.h>
  20. #include "ems4c.h"
  21.  
  22. #define V215 1
  23. #define V170 0
  24.  
  25. #define V130 unsigned char
  26. #define V950 unsigned int
  27. #define V800 static
  28.  
  29. #ifndef FALSE
  30. #define FALSE 0
  31. #define TRUE !FALSE
  32. #endif
  33.  
  34.  
  35. #define V620  200
  36.  
  37.  
  38. #define V630   512
  39.  
  40.  
  41.  
  42. typedef struct V750
  43. {int V900;
  44.  V130 V50[128];
  45. } V750;
  46.  
  47. V800 V750 *V740;
  48. V800 V750 *V760[V630];
  49.  
  50.  
  51.  
  52. typedef struct V500
  53. {
  54.  V950 V650;
  55.  V950 V670;
  56.  V950 V320;
  57.  V950 V400;
  58.  V950 V660;
  59. } V500;
  60.  
  61. V800 V500 *V450;
  62. V800 V500 *V510[V620];
  63.  
  64.  
  65.  
  66. V800 int V410[4];
  67.  
  68. V800 int V570 = 0;
  69. V800 int V560 = 0;
  70. V800 int V430 = 0;
  71. V800 int V210 = -1;
  72.  
  73. #define V10 -1
  74. #define V690     -2
  75. #define V710   -3
  76. #define V720     -4
  77. #define V700    -5
  78. #define V550 -6
  79. #define V40     -7
  80. #define V20   -8
  81. #define V30     -9
  82.  
  83. #define V640     -9
  84. #define V610     -1
  85.  
  86.  
  87.  
  88. V800 int V820(V50,V110)
  89. V130 V50[128];
  90. int V110;
  91. {int V730, V810;
  92.  int V600;
  93.  
  94.  V730 = V110 / 8;
  95.  V810 = V110 % 8;
  96.  V600 = 0x80;
  97.  if(V810>0) V600 = V600 >> V810;
  98.  
  99.  V50[V730] |= V600;
  100. #if V170
  101. printf("SetBit(%d): V730=%d V810=%d V600=%xH V50[%d]=%xH\n",
  102.   V110,V730,V810,V600,V730,V50[V730]);
  103. #endif
  104.  return(0);
  105. }
  106.  
  107. V800 int V140(V50,V110)
  108. V130 V50[128];
  109. int V110;
  110. {int V730, V810;
  111.  int V600;
  112.  
  113.  V730 = V110 / 8;
  114.  V810 = V110 % 8;
  115.  V600 = 0x80;
  116.  if(V810>0) V600 = V600 >> V810;
  117.  
  118.  V50[V730] &= (~V600);
  119. #if V170
  120. printf("$$$ V140(%d): V730=%d V810=%d V600=%xH V50[%d]=%xH\n",
  121.   V110,V730,V810,V600,V730,V50[V730]);
  122. #endif
  123.  return(0);
  124. }
  125.  
  126. V800 int V840(V50,V110)
  127. V130 V50[128];
  128. int V110;
  129. {int V730, V810;
  130.  int V600;
  131.  
  132.  V730 = V110 / 8;
  133.  V810 = V110 % 8;
  134.  V600 = 0x80;
  135.  if(V810>0) V600 = V600 >> V810;
  136. #if V170
  137. printf("TestBit(%d): V730=%d V810=%d V600=%xH V50[%d]=%xH\n",
  138.   V110,V730,V810,V600,V730,V50[V730]);
  139. #endif
  140.  
  141.  if(V600&V50[V730]) return(1);
  142.  else return(0);
  143. }
  144.  
  145.  
  146.  
  147. V800 int V230()
  148. {int V530;
  149.  
  150.  for(V530=0;V530<V560;V530++)
  151.    if(V510[V530]->V650==0) return(V530);
  152.  return(-1);
  153. }
  154.  
  155.  
  156.  
  157. V800 int V240(V660)
  158. int V660;
  159. {int V530,V540;
  160.  int V160 = 0;
  161.  
  162.  if(V660<1)
  163.    {printf("FindFreePages: ERROR: V660=%d\n",V660);
  164.     return(-1);
  165.    }
  166.  
  167. #if V170
  168. printf("$$$ V240: V660=%d ",V660);
  169. #endif
  170.  for(V530=0;V530<=(V570-V660);V530++)
  171.    {
  172.     if(V760[V530]->V900==0)
  173.       {
  174.        V160 = 1;
  175.        for(V540=1;V540<V660;V540++)
  176.          {if(V760[V530+V540]->V900>0)
  177.             {
  178.              V530 = V530 + V540;
  179.              break;
  180.             }
  181.  
  182.           V160++;
  183.          }
  184.  
  185.        if(V160>=V660)
  186.          {
  187. #if V170
  188.           printf("--> V320=%d (%d)\n",V530,V160);
  189. #endif
  190.           return(V530);
  191.          }
  192.       }
  193.    }
  194. #if V170
  195.  printf("--> V320=-1\n");
  196. #endif
  197.  return(-1);
  198. }
  199.  
  200.  
  201. V800 int V300(V780,V670)
  202. int V780;
  203. int V670;
  204. {int V530, V540;
  205.  int V160 = 0;
  206.  
  207.  if(V670<1)
  208.    {printf("FindFreeParas: ERROR: NbrParas\n",V670);
  209.     return(-1);
  210.    }
  211. #if V170
  212. printf("$$$ V300: V780=%d V670=%d ",V780,V670);
  213. #endif
  214.  if((V780<0)||(V780>=V570)) return(V30);
  215.  
  216.  V740 = V760[V780];
  217.  if(1024-V740->V900<V670) return(V30);
  218.  
  219.  for(V530=0;V530<=(1024-V670);V530++)
  220.    {
  221.     if(V840(V740->V50,V530)==0)
  222.       {
  223.        V160 = 1;
  224.  
  225.        for(V540=1;V540<V670;V540++)
  226.          {if(V840(V740->V50,V530+V540)==1)
  227.             {
  228.              V530 = V530 + V540;
  229.              break;
  230.             }
  231.           V160++;
  232.          }
  233.        if(V160>=V670)
  234.          {
  235. #if V170
  236. printf(" --> V790= %d\n",V530);
  237. #endif
  238.           return(V530);
  239.          }
  240.       }
  241.    }
  242.  
  243. #if V170
  244. printf(" --> V790 = -1\n");
  245. #endif
  246.  return(-1);
  247. }
  248.  
  249. V800 int V220(V660)
  250. int V660;
  251. {int V530, V540;
  252.  int V160 = 0;
  253.  
  254.  if(V660<1)
  255.    {printf("FindFreeFrame: ERROR: V660=%d\n",V660);
  256.     return(-1);
  257.    }
  258. #if V170
  259. printf("$$$ V220: V660=%d Frames=[%d %d %d %d] ",
  260.  V660,V410[0],V410[1],V410[2],V410[3]);
  261. #endif
  262.  for(V530=0;V530<=(4-V660);V530++)
  263.    {if(V410[V530]==-1)
  264.       {
  265.        V160 = 1;
  266.        for(V540=V530+1;V540<V660;V540++)
  267.          {if(V410[V540]>=0) break;
  268.  
  269.           V160++;
  270.          }
  271.        if(V160>=V660)
  272.          {
  273. #if V170
  274. printf(" --> V440 = %d\n",V530);
  275. #endif
  276.           return(V530);
  277.          }
  278.       }
  279.     }
  280. #if V170
  281. printf(" --> V440 = -1\n");
  282. #endif
  283.  return(-1);
  284. }
  285.  
  286.  
  287.  
  288. V800 int V310(V320,V660)
  289. int V320;
  290. int V660;
  291. {int V530, V540;
  292.  
  293.  if(V660<1)
  294.    {printf("FindPageFrame: ERROR: V660=%d\n",V660);
  295.     return(-1);
  296.    }
  297. #if V170
  298. printf("$$$ V310: V320=%d V660=%d Frames=[%d %d %d %d] ",
  299.  V320,V660,V410[0],V410[1],V410[2],V410[3]);
  300. #endif
  301.  for(V530=0;V530<=(4-V660);V530++)
  302.    {if(V410[V530]==V320)
  303.       {
  304.        for(V540=1;V540<V660;V540++) if(V410[V530+V540]!=V320+V540) return(-1);
  305. #if V170
  306. printf("--> V440=%d\n",V530);
  307. #endif
  308.        return(V530);
  309.       }
  310.    }
  311. #if V170
  312. printf("--> V440=-1\n");
  313. #endif
  314.  return(-1);
  315. }
  316.  
  317.  
  318.  
  319. V800 int V580(V440,V780)
  320. int V440;
  321. int V780;
  322. {int V150;
  323. #if V170
  324.  printf("$$$ Mapping page %d to frame %d ",V780,V440);
  325. #endif
  326.  if(V410[V440]!=V780)
  327.    {V150 = emsMapMemory(V440,V780,V210);
  328.     if(V150<0) return(V150);
  329. #if V170
  330.     printf(" --> OK\n");
  331. #endif
  332.     V410[V440] = V780;
  333.    }
  334. #if V170
  335.  else printf(" --> already mapped\n");
  336. #endif
  337.  return(0);
  338. }
  339.  
  340.  
  341.  
  342. int emmError(V150)
  343. int V150;
  344. {if(V150)
  345.    {
  346.     if((V150>=V640)&&(V150<=V610))
  347.       {printf("EMM: Error %d (%xH): ",V150,V150);
  348.        switch(V150)
  349.          {case V10:
  350.             puts("EMM already initialized");
  351.             break;
  352.           case V690:
  353.             puts("EMM not initialized");
  354.             break;
  355.           case V710:
  356.             puts("No handles remaining");
  357.             break;
  358.           case V720:
  359.             puts("No pages remaining");
  360.             break;
  361.           case V700:
  362.             puts("No (unmapped) frames remaining");
  363.             break;
  364.           case V550:
  365.             puts("malloc() fails");
  366.             break;
  367.           case V40:
  368.             puts("Size out of range");
  369.             break;
  370.           case V20:
  371.             puts("Handle out of range");
  372.             break;
  373.           case V30:
  374.             puts("Page out of range");
  375.             break;
  376.          }
  377.       }
  378.     else
  379.       {printf("EMS: ");
  380.        emsError(V150);
  381.       }
  382.    }
  383.  return(V150);
  384. }
  385.  
  386.  
  387.  
  388. #if V215
  389.  
  390. int DisplayBits(V120)
  391. V130 V120;
  392. {int V530;
  393.  for(V530=0;V530<8;V530++)
  394.   {if(0x80&V120) printf("1");
  395.    else printf("0");
  396.    V120 = V120<<1;
  397.   }
  398.  return(0);
  399. }
  400.  
  401.  
  402. int PageDump(V575)
  403. int V575;
  404. {int V530,V540;
  405.  int V160 = 0;
  406.  int UsedBytes;
  407.  int FreeBytes;
  408.  int V733;
  409.  int V405;
  410.  puts("*** Page Dump ***");
  411.  for(V530=0;V530<V570;V530++)
  412.    {V740 = V760[V530];
  413.     if(V740->V900==0) continue;
  414.     printf("Page %3d: UsedParas=%2d (%u bytes)\n",
  415.       V530,V740->V900,16*V740->V900);
  416.     V540 = 0;
  417.     UsedBytes = 0;
  418.     FreeBytes = 0;
  419.     while(V540<1024)
  420.       {
  421.        V160 = 0;
  422.        while((V540<1024)&&(V840(V740->V50,V540++)==0)) V160++;
  423.        if(V160>0)
  424.           {FreeBytes += (16*V160);
  425.            printf("   Free: %5u bytes\n",16*V160);
  426.           }
  427.        if(V540<1024) V540--;
  428.  
  429.        V160 = 0;
  430.        while((V540<1024)&&(V840(V740->V50,V540++)==1)) V160++;
  431.        if(V160>0)
  432.           {UsedBytes += (16*V160);
  433.            printf("   Used: %5u bytes\n",16*V160);
  434.           }
  435.        if(V540<1024) V540--;
  436.       }
  437.     printf("   Totals: Used=%u Free=%u (%u)\n",
  438.       UsedBytes,FreeBytes,UsedBytes+FreeBytes);
  439.  
  440.     if(V575)
  441.       {for(V733=0;V733<128;V733+=8)
  442.         {V405=FALSE;
  443.          for(V540=V733;V540<V733+8;V540++) if(V740->V50[V540]) V405=TRUE;
  444.          if(V405)
  445.            {printf("%2d: ",V733);
  446.             for(V540=V733;V540<V733+8;V540++)
  447.               {DisplayBits(V740->V50[V540]);
  448.                printf(" ");
  449.               }
  450.             printf("\n");
  451.            }
  452.         }
  453.       }
  454.    }
  455.  return(0);
  456. }
  457.  
  458. int HandleDump()
  459. {int V530;
  460.  puts("*** V524 Dump ***");
  461.  for(V530=0;V530<V560;V530++)
  462.  
  463.      {V450 = V510[V530];
  464. printf("%2d: V650=%d V670=%d V320=%d V400=%d V660=%d\n",
  465.         V530,V450->V650,
  466.         V450->V670,V450->V320,
  467.         V450->V400,V450->V660);
  468.      }
  469.  return(0);
  470. }
  471.  
  472. #endif
  473.  
  474.  
  475.  
  476. int emmInit(V772,V522)
  477. int V772;
  478. int V522;
  479. {int V530, V540;
  480.  int V842;
  481.  int V442;
  482.  int V736;
  483.  char *malloc();
  484.  int V150;
  485. #if 0
  486.  printf("emmInit: V772=%d V522=%d\n",V772,V522);
  487. #endif
  488.  
  489.  if(V210>=0) return(V10);
  490.  
  491.  if((V772<1)||(V772>V630)) return(V30);
  492.  
  493.  if((V522<1)||(V522>V620)) return(V20);
  494.  V560 = V522;
  495.  
  496.  if((V150=emsLoaded())!=0) return(V150);
  497.  if((V150=emsGetStatus())!=0) return(V150);
  498.  
  499.  V150 = emsGetPages(&V442,&V842);
  500.  if(V150) return(V150);
  501.  if(V772>V442) return(V720);
  502.  V570 = V772;
  503.  
  504.  V150 = emsAllocate(V570,&V210);
  505.  if(V150) return(V150);
  506.  V150 = emsGetFrame(&V430);
  507.  if(V150) return(V150);
  508.  
  509.  for(V530=0;V530<V570;V530++)
  510.    {V740 = (V750 *)malloc(sizeof(V750));
  511.     if(V740==NULL) return(V550);
  512.     V760[V530] = V740;
  513.     V740->V900 = 0;
  514.     for(V540=0;V540<128;V540++) V740->V50[V540] = 0;
  515.    }
  516.  
  517.  for(V530=0;V530<V560;V530++)
  518.    {V450 = (V500 *)malloc(sizeof(V500));
  519.     if(V450==NULL) return(V550);
  520.     V510[V530] = V450;
  521.     V450->V650 = 0;
  522.     V450->V670 = 0;
  523.     V450->V320 = 0;
  524.     V450->V400 = 0;
  525.     V450->V660 = 0;
  526.    }
  527.  
  528.  for(V530=0;V530<4;V530++) V410[V530] = -1;
  529.  return(0);
  530. }
  531.  
  532.  
  533. int emmDone()
  534. {int V150;
  535.  if(V210>=0) if((V150=emsRelease(V210))!=0) return(V150);
  536.  V210 = -1;
  537.  return(0);
  538. }
  539.  
  540.  
  541. int emmPages(V652,V662)
  542. V950 *V652;
  543. V950 *V662;
  544. {int V530;
  545.  V950 V782;
  546.  *V652 = 0;
  547.  *V662 = 0;
  548.  for(V530=0;V530<V570;V530++)
  549.   {V782 = V760[V530]->V900;
  550.    if(V782==0) (*V652)++;
  551.    (*V662) += (1024 - V782);
  552.   }
  553.  return(0);
  554. }
  555.  
  556.  
  557. int emmAlloc(V822)
  558. V950 V822;
  559. {int V530,V532,V540;
  560.  int V782;
  561.  int V780;
  562.  int V772;
  563.  int V524;
  564.  int V444;
  565.  
  566.  if(V210<0) return(V690);
  567.  
  568.  if(V822==0) return(V40);
  569.  
  570.  V524 = V230();
  571.  if(V524<0) return(V710);
  572.  
  573.  if(V822>= 65536-15) V782 = 4*1024;
  574.  else V782 = (V822+15) / 16;
  575.  
  576.  V772 = (V782 + 1023 ) / 1024;
  577. #if V170
  578. printf("$$$ emmAlloc: V822=%d V782=%d V772=%d\n",V822,V782,V772);
  579. #endif
  580.  if(V772>1)
  581.    {
  582.     V780 = V240(V772);
  583.     if(V780<0) return(V720);
  584.  
  585.  
  586.     for(V530=V780;V530<V780+V772;V530++)
  587.       {V740 = V760[V530];
  588. #if V170
  589. printf("$$$ Alloc: V780=%d (V772=%d)\n",V530,V772);
  590. #endif
  591.        if(V530<V780+V772-1)
  592.          {
  593.           V740->V900 = 1024;
  594.           for(V540=0;V540<128;V540++) V740->V50[V540]=0xff;
  595.          }
  596.        else
  597.          {
  598.           V540 = V782 - 1024*(V772-1);
  599.           V740->V900 = V540;
  600.           for(V532=0;V532<V540;V532++) V820(V740->V50,V532);
  601.         }
  602.       }
  603.  
  604.     V450 = V510[V524];
  605.     V450->V650 = V822;
  606.     V450->V670 = V782;
  607.     V450->V320 = V780;
  608.     V450->V400 = 0;
  609.     V450->V660 = V772;
  610.     return(V524);
  611.    }
  612.  else
  613.    {
  614.     for(V530=0;V530<V570;V530++)
  615.       {
  616.        V540 = V300(V530,V782);
  617.        if(V540>=0)
  618.          {
  619.           V740 = V760[V530];
  620.           V740->V900 += V782;
  621.           for(V532=0;V532<V782;V532++) V820(V740->V50,V540+V532);
  622.  
  623.           V450 = V510[V524];
  624.           V450->V650 = V822;
  625.           V450->V670 = V782;
  626.           V450->V320 = V530;
  627.           V450->V400 = V540;
  628.           V450->V660 = 1;
  629.           return(V524);
  630.          }
  631.       }
  632.    }
  633.  
  634.  return(-991);
  635. }
  636.  
  637.  
  638. int emmFree(V524)
  639. int V524;
  640. {int V530, V540;
  641.  V950 V440;
  642.  V950 V320;
  643.  V950 V660;
  644.  V950 V400;
  645.  V950 V670;
  646.  V950 V541;
  647.  
  648.  if(V210<0) return(V690);
  649.  
  650.  if((V524<0)||(V524>V560)) return(V20);
  651.  V450 = V510[V524];
  652.  V320 = V450->V320;
  653.  V660 = V450->V660;
  654.  V400 = V450->V400;
  655.  V670 = V450->V670;
  656. #if V170
  657. printf("$$$ emmFree: V524=%d V320=%d V660=%d V400=%d V670=%d\n",
  658. V524,V320,V660,V400,V670);
  659. #endif
  660.  
  661.  emmUnlock(V524);
  662.  
  663.  if(V660>1)
  664.    {
  665.     for(V530=V320;V530<V320+V660;V530++)
  666.       {
  667. #if V170
  668. printf("$$$ V444: V780=%d\n",V530);
  669. #endif
  670.        V740 = V760[V530];
  671.  
  672.        if(V530<V320+V660-1)
  673.          {
  674.           V740->V900 = 0;
  675.  
  676.           for(V540=0;V540<128;V540++) V740->V50[V540] = 0;
  677.          }
  678.        else
  679.          {
  680.           V541 = V670 - 1024*(V660-1);
  681.           V740->V900 -= V541;
  682.           for(V540=0;V540<V541;V540++) V140(V740->V50,V540);
  683.          }
  684.       }
  685.    }
  686.  else
  687.    {
  688.     V740 = V760[V320];
  689.     V740->V900 -= V450->V670;
  690.  
  691.     for(V540=V400;V540<V400+V670;V540++)
  692.       V140(V740->V50,V540);
  693.    }
  694.  
  695.  V450->V650 = 0;
  696.  V450->V400 = 0;
  697.  V450->V670 = 0;
  698.  V450->V320 = 0;
  699.  V450->V660 = 0;
  700.  return(0);
  701. }
  702.  
  703.  
  704. int emmLock(V524,V812)
  705. int V524;
  706. int *V812;
  707. {int V530, V540;
  708.  V950 V320;
  709.  V950 V660;
  710.  int V150;
  711.  int V440;
  712.  
  713.  if(V210<0) return(V690);
  714.  
  715.  if((V524<0)||(V524>V560)) return(V20);
  716.  V450 = V510[V524];
  717.  V320 = V450->V320;
  718.  V660 = V450->V660;
  719.  
  720.  V440 = V310(V320,V660);
  721.  if(V440>=0)
  722.    {
  723.     *V812 = V430 + 1024*V440 + V450->V400;
  724. #if V170
  725. printf("$$$ emmLock(mapped): V440=%d V400=%d V812=%xH\n",
  726.   V440,V450->V400,*V812);
  727. #endif
  728.     return(0);
  729.    }
  730.  
  731.  V440 = V220(V660);
  732.  if(V440<0) return(V700);
  733.  
  734.  for(V530=0;V530<V660;V530++)
  735.    {
  736.     if((V150=V580(V440+V530,V320+V530))!=0) return(V150);
  737.    }
  738.  
  739.  *V812 = V430 + 1024*V440 + V450->V400;
  740. #if V170
  741. printf("$$$ emmLock: V440=%d V400=%d V812=%xH\n",
  742.   V440,V450->V400,*V812);
  743. #endif
  744.  return(0);
  745. }
  746.  
  747. int emmUnlock(V524)
  748. int V524;
  749. {int V530;
  750.  int V440;
  751.  V950 V320;
  752.  V950 V660;
  753.  
  754.  if(V210<0) return(V690);
  755.  
  756.  if((V524<0)||(V524>V560)) return(V20);
  757.  V450 = V510[V524];
  758.  V320 = V450->V320;
  759.  V660 = V450->V660;
  760.  
  761.  V440 = V310(V320,V660);
  762. #if V170
  763. printf("$$$ emmUnlock: V320=%d V660=%d ==> V440=%d\n",
  764.   V320,V660,V440);
  765. #endif
  766.  if(V440>=0)
  767.    {
  768.     for(V530=V440;V530<V440+V660;V530++)
  769.       {
  770.  
  771.        V410[V530] = -1;
  772.       }
  773.    }
  774.  return(0);
  775. }
  776.  
  777.  
  778. #if V215
  779.  
  780. int emmStats(V524,V771,V731,V821)
  781. int V524;
  782. int *V771;
  783. int *V731;
  784. int *V821;
  785. {
  786.  if((V524<0)||(V524>V560)) return(V20);
  787.  V450 = V510[V524];
  788.  *V771 = V450->V320;
  789.  *V731 = 16 * V450->V400;
  790.  *V821 = 16 * V450->V670;
  791.  return(0);
  792. }
  793.  
  794. #endif
  795.  
  796. #if V215
  797.  
  798. int emmCheck()
  799. {int V530, V540;
  800.  V950 V670;
  801.  V950 V320;
  802.  V950 V400;
  803.  long V526;
  804.  long V534;
  805.  
  806.  if(V210<0) return(V690);
  807.  
  808.  puts("*** emmCheck: checking...");
  809.  for(V530=0;V530<V560;V530++)
  810.    {V450 = V510[V530];
  811.     if(V450->V650>0)
  812.       {
  813.        V670 = V450->V670;
  814.        V320 = V450->V320;
  815.        V400 = V450->V400;
  816.        V526 = (long)1024*V320 + (long)V400;
  817.  
  818.        for(V540=V530+1;V540<V560;V540++)
  819.          {if(V510[V540]->V670>0)
  820.             {
  821.              V534 = (long)1024*V510[V540]->V320
  822.                  + (long)V510[V540]->V400;
  823.              if(V526<V534)
  824.                 {
  825.                  if(V526+(long)V670
  826.                    >=V534+(long)V510[V540]->V670)
  827.                    {
  828.                     printf("emmCheck: ERROR1: V524 %d overlaps %d\n",V530,V540);
  829.                     return(FALSE);
  830.                    }
  831.                 }
  832.              else if(V534<V526)
  833.                 {
  834.                  if(V526+(long)V670
  835.                    <=V534+(long)V510[V540]->V670)
  836.                    {
  837.                     printf("emmCheck: ERROR2: V524 %d overlaps %d\n",V530,V540);
  838.                     return(FALSE);
  839.                    }
  840.                 }
  841.              else
  842.                 {
  843.                  printf("emmCheck: ERROR3: V524 %d overlaps %d\n",V530,V540);
  844.                  return(FALSE);
  845.                 }
  846.             }
  847.          }
  848.       }
  849.    }
  850.  return(TRUE);
  851. }
  852.  
  853. #endif
  854.  
  855.